home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1998 / MacHack 1998.toast / Papers / C++ Exceptions / µShell / Core Utilities / MemUtils.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-03-14  |  3.3 KB  |  146 lines  |  [TEXT/CWIE]
  1. #ifndef __MEMUTILS__
  2. #define __MEMUTILS__
  3. #pragma once
  4.  
  5. #ifndef __MEMORY__
  6. #include <Memory.h>
  7. #endif
  8.  
  9. //------------------------------------------------------------------------------
  10.  
  11. enum HandleState
  12. {
  13.     kHDispose    = 0x8000,    // Auto-dispose
  14.     kHMoveHi    = 0x4000,    // Move hi in heap
  15.     kHClear        = 0x1000,    // 
  16.     kHCritical    = 0x0800,    // Allocate from reserve if needed
  17.     kHSysHeap    = 0x0400,    // Allocate in system heap
  18.     kHTempMem    = 0x0200,    // Allocate in temp mem
  19.     kHLocked    = 0x0080,    // -- correspond to HState bits
  20.     kHPurge        = 0x0040,
  21.     kHResource    = 0x0020,
  22.     
  23.     kHLockHi    = kHMoveHi+kHLocked
  24. };
  25.  
  26. //------------------------------------------------------------------------------
  27.  
  28. class CAutoHandle
  29. {
  30. protected:
  31.     Handle        fHandle;
  32.     HandleState    fState;
  33.     
  34.     void _CAutoHandle(Handle h, HandleState desiredState);
  35.  
  36. public:
  37.     CAutoHandle(Size size, HandleState desiredState);
  38.     CAutoHandle(const void* data, Size size, HandleState desiredState);
  39.     inline CAutoHandle(Handle h,  HandleState desiredState)
  40.     {
  41.         _CAutoHandle(h, desiredState);
  42.     }
  43.     ~CAutoHandle();
  44.  
  45.     inline void AutoDispose()    { fState = (HandleState) (fState | kHDispose);  }
  46.     inline void DontDispose()    { fState = (HandleState) (fState & ~kHDispose); }
  47.     
  48.     inline void AdoptedHandle()    { fHandle = nil; }
  49.  
  50. //    inline operator const Handle() const     { return fHandle; }
  51.     inline operator Handle()                { return fHandle; }
  52.  
  53.     inline const void* operator*() const     { return *fHandle; }
  54.     inline void* operator*()                { return *fHandle; }
  55. };
  56.  
  57. //------------------------------------------------------------------------------
  58.  
  59. class CTempHandle : public CAutoHandle
  60. {
  61. public:
  62.     inline CTempHandle(
  63.         Handle    h,
  64.         bool    lock = false,
  65.         bool    moveHi = false)
  66.     :    CAutoHandle(h, (HandleState) (kHTempMem | kHDispose
  67.                        | (lock   ? kHLocked : 0)
  68.                        | (moveHi ? kHMoveHi : 0)))
  69.     {
  70.     }
  71.  
  72.     inline CTempHandle(
  73.         const void* data,
  74.         Size        size,
  75.         bool        lock = false,
  76.         bool        moveHi = false)
  77.     :    CAutoHandle(data, size, (HandleState) (kHTempMem | kHDispose
  78.                           | (lock   ? kHLocked : 0)
  79.                           | (moveHi ? kHMoveHi : 0)))
  80.     {
  81.     }
  82.  
  83.     inline CTempHandle(
  84.         Size    size,
  85.         bool    lock = false,
  86.         bool    moveHi = false)
  87.     :    CAutoHandle(size, (HandleState) (kHTempMem | kHDispose
  88.                           | (lock   ? kHLocked : 0)
  89.                           | (moveHi ? kHMoveHi : 0)))
  90.     {
  91.     }
  92.  
  93.     inline CTempHandle(
  94.         Size    size,
  95.         HandleState    state)
  96.     :    CAutoHandle(size, (HandleState) (kHTempMem | kHDispose | state))
  97.     {
  98.     }
  99.  
  100.     inline CTempHandle(
  101.         const void* data,
  102.         Size        size,
  103.         HandleState    state)
  104.     :    CAutoHandle(data, size, (HandleState) (kHTempMem | kHDispose | state))
  105.     {
  106.     }
  107.  
  108.     ~CTempHandle();
  109.  
  110.     inline Handle Release() // let our handle float when we go out of scope
  111.     {
  112.         fState = (HandleState) (fState & ~(kHDispose|kHLocked));
  113.         return fHandle;
  114.     }
  115.     
  116.     inline void Unlock()
  117.     {
  118.         if (!(fState & kHLocked))
  119.         {
  120.             HUnlock(fHandle);
  121.         }
  122.         else if (qDebug)
  123.         {
  124.             Debugger();
  125.         }
  126.     }
  127. };
  128.  
  129. //------------------------------------------------------------------------------
  130.  
  131. class WithHandleLocked : public CAutoHandle
  132. {
  133. public:
  134.     WithHandleLocked(Handle h, bool moveHi = false) : CAutoHandle(h, moveHi ? kHLockHi : kHLocked) {}
  135. };
  136.  
  137. //------------------------------------------------------------------------------
  138.  
  139. void CopyHandle(Handle src, Handle dst);
  140.  
  141. void BlockZero(void* p, Size size);
  142.  
  143. //------------------------------------------------------------------------------
  144.  
  145. #endif // __MEMUTILS__
  146.